// app.js
App({
  globalData: {
    userInfo: null,
    isVip: false,
    freeUsageCount: 5, // 每日免费次数为5次
    lastUsageDate: '',
    apiBaseUrl: 'https://api.example.com/v1', // 替换为您的API端点
    // 本地处理模式已禁用，现在只做简单回显处理
    useLocalProcess: false,
    // 腾讯云数据万象配置
    tcbConfig: {
      bucket: 'mitou-1302192113', // 您的存储桶名称，例如: watermark-removal-1234567890
      region: 'ap-beijing',           // 存储桶所在地域，例如: ap-shanghai
      cosEndpoint: 'cos.ap-beijing.myqcloud.com', // COS终端节点
      ciEndpoint: 'ci.ap-beijing.myqcloud.com',   // 数据万象终端节点
      // 腾讯云API密钥，仅在开发环境使用，生产环境应从后端获取临时密钥
      secretId: 'AKIDz2GXjnhSWTSL6kCqKbfV8bswnV2NVQ9f',     // 您的SecretId，请勿在正式环境中暴露
      secretKey: '2rWyJUVJwOgmihYBbJq9E7pKcgZG2iOx',   // 您的SecretKey，请勿在正式环境中暴露
      // 水印处理参数
      watermarkParams: {
        // 默认区域处理参数 (通常水印在右下角)
        image: {
          defaultRegion: {
            x: 50,      // 水印区域距左边缘位置（像素）
            y: 50,      // 水印区域距上边缘位置（像素）
            width: 200, // 水印区域宽度（像素）
            height: 50  // 水印区域高度（像素）
          },
          // 智能水印参数 - 通过数据万象的智能识别水印
          smartParams: 'watermark/3/type/2'
        },
        video: {
          defaultRegion: {
            x: 20,
            y: 20,
            width: 150,
            height: 40
          },
          // 视频水印参数 - 通过数据万象的智能识别水印
          smartParams: 'watermark/3/type/2'
        }
      }
    },
    // 处理结果缓存
    processCache: {},
    // 添加分享记录，记录已经分享过的好友openid，防止重复计算
    shareRecords: {},
    sharedBy: [], // 记录分享来源
    privacyAuthorized: false, // 是否已经同意隐私协议
  },
  
  onLaunch() {
    // 初始化使用次数
    this.initUsageCount();
    
    // 检查VIP状态
    this.checkVipStatus();
    
    // 初始化用户信息
    this.initUserInfo();
    
    // 初始化处理缓存
    this.initProcessCache();
    
    // 初始化分享记录
    this.initShareRecords();
    
    // 设置隐私权限监听
    this.setupPrivacyListener();
    
    // 恢复隐私授权状态
    this.restorePrivacyState();
    
    // 检查是否同意条款
    const hasAgreed = wx.getStorageSync('hasAgreedToTerms');
    if (!hasAgreed) {
      // 将在第一页提示同意
      this.globalData.needAgreement = true;
    }
  },
  
  // 设置隐私权限监听
  setupPrivacyListener() {
    // 监听隐私权限请求
    wx.onNeedPrivacyAuthorization((resolve) => {
      // 显示隐私授权弹窗
      this.showPrivacyDialog(resolve);
    });
  },
  
  // 显示隐私授权弹窗
  showPrivacyDialog(callback) {
    const that = this;
    
    // 如果已经同意过隐私协议，直接调用回调函数
    if (this.globalData.privacyAuthorized) {
      if (callback && typeof callback === 'function') {
        callback({
          event: 'agree',
          action: 'authorized'
        });
      }
      return;
    }
    
    // 显示隐私协议弹窗
    wx.showModal({
      title: '用户隐私保护提示',
      content: '我们非常重视您的个人信息保护。在使用"保存到相册"功能前，请您仔细阅读并同意《用户隐私保护指引》，了解我们对您个人信息的处理规则。',
      confirmText: '同意并继续',
      cancelText: '暂不使用',
      success: (res) => {
        if (res.confirm) {
          // 用户同意隐私协议
          that.globalData.privacyAuthorized = true;
          wx.setStorageSync('privacyAuthorized', true);
          
          if (callback && typeof callback === 'function') {
            callback({
              event: 'agree',
              action: 'authorized'
            });
          }
        } else {
          // 用户拒绝隐私协议
          if (callback && typeof callback === 'function') {
            callback({
              event: 'disagree',
              action: 'unauthorized'
            });
          }
        }
      },
      fail: () => {
        if (callback && typeof callback === 'function') {
          callback({
            event: 'error',
            action: 'fail'
          });
        }
      }
    });
  },
  
  // 检查并请求隐私授权
  checkPrivacyAuthorization() {
    return new Promise((resolve, reject) => {
      // 检查是否已经同意隐私协议
      const authorized = wx.getStorageSync('privacyAuthorized');
      if (authorized) {
        this.globalData.privacyAuthorized = true;
        resolve(true);
        return;
      }
      
      // 未同意，显示隐私授权弹窗
      this.showPrivacyDialog((res) => {
        if (res.event === 'agree') {
          resolve(true);
        } else {
          reject(new Error('用户未同意隐私协议'));
        }
      });
    });
  },
  
  // 初始化每日使用次数
  initUsageCount() {
    const lastUsageDate = wx.getStorageSync('lastUsageDate');
    const today = new Date().toDateString();
    const deviceId = this.getDeviceId(); // 获取设备唯一标识
    
    // 从云端存储获取使用记录，这里模拟实现
    const cloudUsageKey = `usage_${deviceId}`;
    let cloudUsageData = wx.getStorageSync(cloudUsageKey);
    
    if (!cloudUsageData) {
      // 第一次使用，创建记录
      cloudUsageData = {
        deviceId: deviceId,
        lastDate: today,
        count: 5
      };
      wx.setStorageSync(cloudUsageKey, cloudUsageData);
    }
    
    if (lastUsageDate !== today) {
      // 新的一天，检查是否应该重置
      if (cloudUsageData.lastDate !== today) {
        // 云端记录也显示是新的一天，可以重置
        cloudUsageData.lastDate = today;
        cloudUsageData.count = 5;
        wx.setStorageSync(cloudUsageKey, cloudUsageData);
        
        // 本地存储也更新
        wx.setStorageSync('freeUsageCount', 5);
        wx.setStorageSync('lastUsageDate', today);
        this.globalData.freeUsageCount = 5;
      } else {
        // 云端记录显示今天已经使用过，用户可能清除了缓存
        // 使用云端记录的使用次数
        wx.setStorageSync('freeUsageCount', cloudUsageData.count);
        wx.setStorageSync('lastUsageDate', today);
        this.globalData.freeUsageCount = cloudUsageData.count;
      }
    } else {
      // 同一天继续使用
      const localCount = wx.getStorageSync('freeUsageCount') || 5;
      
      // 使用本地和云端中较小的值，避免用户清除缓存刷新次数
      const finalCount = Math.min(localCount, cloudUsageData.count);
      cloudUsageData.count = finalCount;
      wx.setStorageSync(cloudUsageKey, cloudUsageData);
      
      this.globalData.freeUsageCount = finalCount;
      wx.setStorageSync('freeUsageCount', finalCount);
    }
  },
  
  // 获取设备唯一标识
  getDeviceId() {
    let deviceId = wx.getStorageSync('device_id');
    
    if (!deviceId) {
      // 生成一个随机ID并永久保存
      deviceId = 'device_' + Date.now() + '_' + Math.random().toString(36).substring(2, 10);
      wx.setStorageSync('device_id', deviceId);
    }
    
    return deviceId;
  },
  
  // 更新免费使用次数
  updateFreeUsageCount(newCount) {
    // 更新本地存储
    wx.setStorageSync('freeUsageCount', newCount);
    this.globalData.freeUsageCount = newCount;
    
    // 同时更新云端记录
    const deviceId = this.getDeviceId();
    const cloudUsageKey = `usage_${deviceId}`;
    let cloudUsageData = wx.getStorageSync(cloudUsageKey);
    
    if (cloudUsageData) {
      cloudUsageData.count = newCount;
      wx.setStorageSync(cloudUsageKey, cloudUsageData);
    }
  },
  
  // 检查VIP状态
  checkVipStatus() {
    // 暂时禁用VIP功能，将来再恢复
    this.globalData.isVip = false;
    
    // 将本地存储中的VIP状态也设置为false
    wx.setStorageSync('isVIP', false);
  },
  
  // 初始化用户信息
  initUserInfo() {
    const userInfo = wx.getStorageSync('userInfo');
    if (userInfo) {
      this.globalData.userInfo = userInfo;
    }
  },
  
  // 初始化处理缓存
  initProcessCache() {
    // 从本地存储加载缓存记录
    const processCache = wx.getStorageSync('processCache') || {};
    
    // 缓存清理：删除超过7天的缓存
    const now = new Date().getTime();
    const oneWeek = 7 * 24 * 60 * 60 * 1000; // 7天的毫秒数
    
    for (const key in processCache) {
      if (processCache[key].timestamp && (now - processCache[key].timestamp > oneWeek)) {
        delete processCache[key];
      }
    }
    
    this.globalData.processCache = processCache;
    wx.setStorageSync('processCache', processCache);
  },
  
  // 保存处理结果到缓存
  saveToProcessCache(filePath, result) {
    if (!filePath || !result || !result.success) return;
    
    const md5Key = this.simpleMD5(filePath);
    const cacheItem = {
      result: result,
      timestamp: new Date().getTime()
    };
    
    this.globalData.processCache[md5Key] = cacheItem;
    wx.setStorageSync('processCache', this.globalData.processCache);
  },
  
  // 从缓存获取处理结果
  getFromProcessCache(filePath) {
    if (!filePath) return null;
    
    const md5Key = this.simpleMD5(filePath);
    const cacheItem = this.globalData.processCache[md5Key];
    
    if (cacheItem && cacheItem.result) {
      // 检查缓存是否过期（24小时）
      const now = new Date().getTime();
      const oneDay = 24 * 60 * 60 * 1000;
      if (now - cacheItem.timestamp <= oneDay) {
        return cacheItem.result;
      }
    }
    
    return null;
  },
  
  // 简单的MD5替代函数（生产环境应使用实际的MD5）
  simpleMD5(text) {
    // 这里是简化版本，实际应用应使用真正的MD5算法
    if (!text) return '';
    const hashNum = Array.from(text).reduce((acc, char) => {
      return acc + char.charCodeAt(0);
    }, 0);
    return 'key_' + hashNum;
  },
  
  // 添加项目到历史记录
  addToHistory(item) {
    // 获取现有历史记录
    const history = wx.getStorageSync('watermarkHistory') || [];
    
    // 添加带时间戳和ID的新项目
    const newItem = {
      ...item,
      id: Date.now().toString(),
      createdAt: new Date().toISOString()
    };
    
    // 添加到数组开头
    history.unshift(newItem);
    
    // 只保留最后30个项目（或您想要的任何限制）
    const trimmedHistory = history.slice(0, 30);
    
    // 保存回存储
    wx.setStorageSync('watermarkHistory', trimmedHistory);
    
    return newItem;
  },
  
  // 处理媒体（通常会调用API）
  processMedia(url, type, callback) {
    // 使用提供的API进行去水印处理
    // API: https://api.mz9.top/api/analysis/index.php
    
    const apiUrl = 'https://api.mz9.top/api/analysis/index.php';
    const apiKey = 'b72f0eb0-6dc4-2136-74bc-2cdd099d81e83f82664c';
    
    // 显示加载提示
    wx.showLoading({
      title: '正在解析并去除水印...',
      mask: true // 防止用户触摸操作
    });
    
    // 调用API
    wx.request({
      url: apiUrl,
      method: 'GET',
      data: {
        apikey: apiKey,
        url: url
      },
      success: (res) => {
        wx.hideLoading();
        
        if (res.data && res.data.code === 200 && res.data.success) {
          // 处理成功
          const apiData = res.data.data;
          
          // 构造视频URL，优先使用video_url或downurl字段
          let videoUrl = '';
          if (apiData.type === 'video') {
            videoUrl = apiData.video_url || apiData.downurl || apiData.url || '';
            
            // 预处理视频URL，防止跨域问题
            videoUrl = this.preprocessVideoUrl(videoUrl);
          } else {
            videoUrl = apiData.url || '';
          }
          
          // 根据返回数据构造结果
          const result = {
            success: true,
            data: {
              type: apiData.type || type, // 使用API返回的类型，如果没有则使用猜测的类型
              url: videoUrl, // 无水印链接
              video_url: apiData.video_url, // 保存原始字段，以便后续处理
              downurl: apiData.downurl, // 保存原始字段，以便后续处理
              cover: apiData.cover_url || apiData.cover || '', // 封面URL（如果有）
              title: apiData.title || '无水印内容',
              originalUrl: url, // 原始带水印的URL
              isDouyinVideo: videoUrl.includes('douyin') || videoUrl.includes('365yg.com')
            }
          };
          
          if (callback) {
            callback(result);
          }
        } else {
          // 处理失败
          if (callback) {
            callback({
              success: false,
              message: res.data?.message || '解析失败，请检查链接是否正确或尝试其他平台链接'
            });
          }
        }
      },
      fail: (err) => {
        wx.hideLoading();
        
        // 处理API请求失败情况
        if (callback) {
          callback({
            success: false,
            message: '网络请求失败，请检查网络连接后重试'
          });
        }
      }
    });
  },
  
  // 预处理视频URL
  preprocessVideoUrl(url) {
    if (!url) return '';
    
    // 移除URL中的跨域引用参数
    let processedUrl = url.split('#')[0];
    
    // 检查并调整URL格式
    if (processedUrl.includes('douyin.com') || 
        processedUrl.includes('365yg.com') || 
        processedUrl.includes('toutiao')) {
      
      // 检查并确保URL有http/https前缀
      if (!processedUrl.startsWith('http')) {
        processedUrl = 'https://' + processedUrl;
      }
      
      // 尝试重写为可播放格式
      // 抖音视频可能的处理方法 - 这只是一个示例，可能需要根据实际情况修改
      if (processedUrl.includes('?')) {
        processedUrl = processedUrl.split('?')[0];
      }
    }
    
    return processedUrl;
  },
  
  // 处理本地媒体文件
  processLocalMedia(filePath, type, coverPath = '', callback, watermarkRegion = null) {
    // 显示加载提示
    wx.showLoading({
      title: '正在处理水印...',
      mask: true
    });

    // 先检查缓存中是否有结果
    const cachedResult = this.getFromProcessCache(filePath);
    if (cachedResult) {
      wx.hideLoading();
      wx.showToast({
        title: '已完成处理',
        icon: 'success',
        duration: 2000
      });
      
      // 延迟一点返回缓存结果，让用户感知到处理过程
      setTimeout(() => {
        if (callback && typeof callback === 'function') {
          callback(cachedResult);
        }
      }, 500);
      return;
    }

    // 简化处理 - 直接返回原始文件
    setTimeout(() => {
      const compatibleResult = {
        success: true,
        data: {
          type: type,
          url: filePath, // 直接使用原文件路径
          cover: type === 'video' ? (coverPath || '') : filePath,
          title: '已处理' + (type === 'image' ? '图片' : '视频'),
          originalUrl: filePath
        }
      };
      
      // 保存结果到缓存
      this.saveToProcessCache(filePath, compatibleResult);
      
      wx.hideLoading();
      wx.showToast({
        title: '处理完成',
        icon: 'success',
        duration: 2000
      });
      
      // 返回结果给调用方
      if (callback && typeof callback === 'function') {
        callback(compatibleResult);
      }
    }, 1500);
    
    return;

    /*
    // 使用简化处理流程 - 暂时跳过COS处理，使用本地处理模拟
    if (this.globalData.useLocalProcess) {
      if (type === 'image' && watermarkRegion) {
        // 图片本地处理 - 使用canvas涂抹水印区域
        this.processLocalImage(filePath, watermarkRegion, (result) => {
          if (result.success) {
            const compatibleResult = {
              success: true,
              data: {
                type: 'image',
                url: result.processedPath,
                cover: result.processedPath,
                title: '已处理图片',
                originalUrl: filePath
              }
            };
            
            // 保存结果到缓存
            this.saveToProcessCache(filePath, compatibleResult);
            
            wx.hideLoading();
            wx.showToast({
              title: '水印已去除',
              icon: 'success',
              duration: 2000
            });
            
            if (callback && typeof callback === 'function') {
              callback(compatibleResult);
            }
          } else {
            this.handleLocalProcessError(callback);
          }
        });
      } else if (type === 'video') {
        // 视频本地处理 - 提取首帧处理并保存视频
        this.processLocalVideo(filePath, coverPath, watermarkRegion, (result) => {
          if (result.success) {
            const compatibleResult = {
              success: true,
              data: {
                type: 'video',
                url: result.processedPath || filePath,
                cover: result.coverPath || coverPath || '',
                title: '已处理视频',
                originalUrl: filePath
              }
            };
            
            // 保存结果到缓存
            this.saveToProcessCache(filePath, compatibleResult);
            
            wx.hideLoading();
            wx.showToast({
              title: '视频已保存',
              icon: 'success',
              duration: 2000
            });
            
            if (callback && typeof callback === 'function') {
              callback(compatibleResult);
            }
          } else {
            this.handleLocalProcessError(callback);
          }
        });
      } else {
        // 默认简单处理
        setTimeout(() => {
          const tempFilePath = `${wx.env.USER_DATA_PATH}/processed_${new Date().getTime()}.${type === 'video' ? 'mp4' : 'jpg'}`;
          
          // 复制源文件到处理后的路径（简单模拟处理）
          wx.getFileSystemManager().copyFile({
            srcPath: filePath,
            destPath: tempFilePath,
            success: () => {
              const compatibleResult = {
                success: true,
                data: {
                  type: type,
                  url: tempFilePath,
                  cover: type === 'video' ? (coverPath || '') : tempFilePath,
                  title: '已处理' + (type === 'image' ? '图片' : '视频'),
                  originalUrl: filePath
                }
              };
              
              // 保存结果到缓存
              this.saveToProcessCache(filePath, compatibleResult);
              
              wx.hideLoading();
              wx.showToast({
                title: '处理完成',
                icon: 'success',
                duration: 2000
              });
              
              if (callback && typeof callback === 'function') {
                callback(compatibleResult);
              }
            },
            fail: (err) => {
              console.error('文件处理失败:', err);
              this.handleLocalProcessError(callback);
            }
          });
        }, 1500);
      }
      
      return;
    }

    // 使用腾讯云数据万象处理水印
    // 创建fileInfo对象
    const fileInfo = {
      filePath: filePath,
      objectKey: `watermark-removal/${new Date().getTime()}_${Math.floor(Math.random() * 10000)}.${type === 'video' ? 'mp4' : 'jpg'}`,
      fileType: type
    };
    
    // 创建处理选项
    const options = {
      watermarkRegion: watermarkRegion,
      type: type
    };
    
    this.processWithCi(fileInfo, options, (result) => {
      wx.hideLoading();
      if (result.success) {
        // 向用户说明水印处理情况
        wx.showToast({
          title: '水印处理完成',
          icon: 'success',
          duration: 2000
        });
        
        // 转换结果格式以兼容现有代码
        const compatibleResult = {
          success: true,
          data: {
            type: type,
            url: result.result?.filePath || filePath,
            cover: type === 'video' ? (coverPath || '') : (result.result?.filePath || filePath),
            title: '已去水印' + (type === 'image' ? '图片' : '视频'),
            originalUrl: filePath
          }
        };
        
        // 保存结果到缓存
        this.saveToProcessCache(filePath, compatibleResult);
        
        // 返回结果给调用方
        if (callback && typeof callback === 'function') {
          callback(compatibleResult);
        }
      } else {
        wx.showToast({
          title: result.message || '处理失败',
          icon: 'none',
          duration: 2000
        });
        
        // 返回错误结果
        if (callback && typeof callback === 'function') {
          callback({
            success: false,
            message: result.message || '处理失败'
          });
        }
      }
    });
    */
  },
  
  /*
  // 本地处理图片水印
  processLocalImage(filePath, watermarkRegion, callback) {
    // 获取图片信息
    wx.getImageInfo({
      src: filePath,
      success: (imgInfo) => {
        const imageWidth = imgInfo.width;
        const imageHeight = imgInfo.height;
        
        // 创建canvas上下文
        const ctx = wx.createCanvasContext('watermarkCanvas');
        
        // 绘制原始图片
        ctx.drawImage(filePath, 0, 0, imageWidth, imageHeight);
        
        // 计算水印区域
        const region = watermarkRegion || {
          x: Math.floor(imageWidth * 0.7),
          y: Math.floor(imageHeight * 0.8),
          width: Math.floor(imageWidth * 0.25),
          height: Math.floor(imageHeight * 0.15)
        };
        
        // 从原图中采样周围颜色
        const sampleX = Math.max(0, region.x - 5);
        const sampleY = Math.max(0, region.y - 5);
        
        // 使用模糊或颜色填充覆盖水印区域
        ctx.save();
        ctx.beginPath();
        ctx.rect(region.x, region.y, region.width, region.height);
        ctx.fillStyle = '#ffffff'; // 使用白色填充
        ctx.globalAlpha = 0.8; // 半透明
        ctx.fill();
        ctx.restore();
        
        // 应用滤镜模糊效果模拟
        ctx.save();
        ctx.beginPath();
        ctx.rect(region.x, region.y, region.width, region.height);
        ctx.fillStyle = 'rgba(255,255,255,0.5)'; 
        ctx.fill();
        ctx.restore();
        
        // 绘制并保存
        ctx.draw(false, () => {
          setTimeout(() => {
            // 保存到临时文件
            wx.canvasToTempFilePath({
              canvasId: 'watermarkCanvas',
              success: (res) => {
                callback({
                  success: true,
                  processedPath: res.tempFilePath
                });
              },
              fail: (err) => {
                console.error('保存canvas失败:', err);
                callback({
                  success: false,
                  message: '图片处理失败'
                });
              }
            });
          }, 500);
        });
      },
      fail: (err) => {
        console.error('获取图片信息失败:', err);
        callback({
          success: false,
          message: '获取图片信息失败'
        });
      }
    });
  },
  
  // 本地处理视频水印
  processLocalVideo(filePath, coverPath, watermarkRegion, callback) {
    // 使用先进行视频处理再保存的策略
    wx.showLoading({
      title: '处理视频中...',
      mask: true
    });
    
    // 保存原视频但修改文件名，模拟处理
    const processedVideoPath = `${wx.env.USER_DATA_PATH}/processed_video_${new Date().getTime()}.mp4`;
    
    // 复制视频文件（实际应用中可以在此处进行实际的水印处理）
    wx.getFileSystemManager().copyFile({
      srcPath: filePath,
      destPath: processedVideoPath,
      success: () => {
        // 处理视频成功
        wx.hideLoading();
        
        // 试着保存到相册
        wx.saveVideoToPhotosAlbum({
          filePath: processedVideoPath,
          success: () => {
            wx.showToast({
              title: '已保存到相册',
              icon: 'success',
              duration: 2000
            });
          },
          fail: (saveErr) => {
            console.error('保存到相册失败:', saveErr);
            // 即使保存到相册失败也不算处理失败
            wx.showToast({
              title: '处理成功但保存失败',
              icon: 'none',
              duration: 2000
            });
          },
          complete: () => {
            // 处理视频封面
            if (coverPath && watermarkRegion) {
              this.processLocalImage(coverPath, watermarkRegion, (coverResult) => {
                callback({
                  success: true,
                  processedPath: processedVideoPath,
                  coverPath: coverResult.success ? coverResult.processedPath : coverPath
                });
              });
            } else {
              callback({
                success: true,
                processedPath: processedVideoPath,
                coverPath: coverPath
              });
            }
          }
        });
      },
      fail: (err) => {
        console.error('视频文件处理失败:', err);
        wx.hideLoading();
        
        // 如果处理失败，尝试直接使用原视频
        callback({
          success: true, // 仍返回成功，使用原视频
          processedPath: filePath,
          coverPath: coverPath,
          message: '视频处理失败，使用原始视频'
        });
        
        wx.showToast({
          title: '处理失败，使用原视频',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },
  
  // 处理本地处理错误
  handleLocalProcessError(callback) {
    wx.hideLoading();
    wx.showToast({
      title: '处理失败',
      icon: 'none',
      duration: 2000
    });
    
    if (callback && typeof callback === 'function') {
      callback({
        success: false,
        message: '本地处理失败，请重试'
      });
    }
  },
  */
  
  // 根据CI API提供的参数处理媒体文件
  processWithCi(fileInfo, options, callback) {
    // 检查回调函数是否存在
    if (!callback || typeof callback !== 'function') {
      wx.showToast({
        title: '回调函数错误',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    const { filePath, objectKey, fileType } = fileInfo;
    const isVideo = fileType === 'video';
    const defaultSettings = {
      // 默认水印处理参数
      watermarkRemoval: true,
      enhanceQuality: isVideo ? false : true, // 默认只为图片启用画质增强
      smartDetection: true, // 智能检测水印区域
      processingLevel: isVideo ? 'standard' : 'high' // 视频默认标准处理，图片默认高质量处理
    };
    
    // 合并用户选项和默认选项
    const settings = {...defaultSettings, ...options};
    
    // 获取临时密钥并上传到COS
    this.getTempCosKey((keyResult) => {
      if (!keyResult.success) {
        callback({
          success: false,
          message: keyResult.message || '获取COS授权失败'
        });
        return;
      }
      
      // 显示上传进度
      wx.showLoading({
        title: '准备上传...',
        mask: true
      });
      
      // 上传到COS
      this.uploadToCos(filePath, objectKey, keyResult.credentials, (uploadResult) => {
        if (!uploadResult.success) {
          wx.hideLoading();
          callback({
            success: false,
            message: uploadResult.message || '上传失败'
          });
          return;
        }
        
        // 显示处理进度
        wx.showLoading({
          title: '处理中...',
          mask: true
        });
        
        // 获取处理后的URL
        const cosUrl = uploadResult.url;
        const processOptions = {
          type: fileType,
          watermarkRegion: options.watermarkRegion
        };
        
        // 不同的水印处理参数
        const processedUrl = this.buildCiProcessUrl(objectKey, processOptions);
        console.log('处理URL:', processedUrl);
        
        // 根据媒体类型执行不同的处理逻辑
        if (isVideo) {
          // 视频下载处理
          this.downloadProcessedMedia(processedUrl, (downloadResult) => {
            wx.hideLoading();
            if (downloadResult.success) {
              callback({
                success: true,
                result: {
                  filePath: downloadResult.tempFilePath,
                  originalPath: filePath,
                  objectKey: objectKey,
                  fileType: fileType,
                  processedUrl: processedUrl
                }
              });
            } else {
              callback({
                success: false,
                message: downloadResult.message || '视频处理失败'
              });
            }
          });
        } else {
          // 图片下载处理
          this.downloadProcessedMedia(processedUrl, (downloadResult) => {
            wx.hideLoading();
            if (downloadResult.success) {
              callback({
                success: true,
                result: {
                  filePath: downloadResult.tempFilePath,
                  originalPath: filePath,
                  objectKey: objectKey,
                  fileType: fileType,
                  processedUrl: processedUrl
                }
              });
            } else {
              callback({
                success: false,
                message: downloadResult.message || '图片处理失败'
              });
            }
          });
        }
      });
    });
  },
  
  // 下载处理后的媒体文件
  downloadProcessedMedia(url, callback) {
    wx.downloadFile({
      url: url,
      success: (res) => {
        if (res.statusCode === 200) {
          callback({
            success: true,
            tempFilePath: res.tempFilePath
          });
        } else {
          callback({
            success: false,
            message: `下载失败，状态码: ${res.statusCode}`
          });
        }
      },
      fail: (err) => {
        callback({
          success: false,
          message: `下载错误: ${err.errMsg || JSON.stringify(err)}`
        });
      }
    });
  },
  
  // 构建CI处理URL
  buildCiProcessUrl(objectKey, options = {}) {
    const { bucket, region, ciEndpoint, watermarkParams } = this.globalData.tcbConfig;
    
    // 构建处理参数
    let processParams = '';
    
    if (options.type === 'image') {
      // 图片水印去除处理
      if (options.watermarkRegion) {
        // 使用用户指定的水印区域
        processParams = `imageMogr2/crop/${options.watermarkRegion.width}x${options.watermarkRegion.height}a${options.watermarkRegion.x}a${options.watermarkRegion.y}/dissolve/100`;
      } else if (watermarkParams && watermarkParams.image) {
        // 使用智能水印识别和去除
        processParams = watermarkParams.image.smartParams;
      } else {
        // 使用默认区域参数
        const defaultRegion = watermarkParams.image.defaultRegion;
        processParams = `imageMogr2/crop/${defaultRegion.width}x${defaultRegion.height}a${defaultRegion.x}a${defaultRegion.y}/dissolve/100`;
      }
    } else if (options.type === 'video') {
      // 视频水印去除 - 使用更多的处理参数
      if (options.watermarkRegion) {
        // 使用用户指定的水印区域
        const region = options.watermarkRegion;
        // 视频水印坐标系是百分比，转换为绝对坐标
        processParams = `watermark/4/type/2/gravity/southeast/dx/${region.x}/dy/${region.y}/width/${region.width}/height/${region.height}`;
      } else {
        // 使用其他视频水印去除参数 - 改用基础参数
        processParams = 'watermark/3/type/2';
      }
    }
    
    // 返回带处理参数的URL
    return `https://${bucket}.${ciEndpoint}/${objectKey}?${processParams}`;
  },
  
  // 上传文件到COS
  uploadToCos(filePath, objectKey, credentials, callback) {
    const { bucket, region, cosEndpoint } = this.globalData.tcbConfig;
    const { tmpSecretId, tmpSecretKey, sessionToken } = credentials;
    
    // 构建上传URL
    const cosUrl = `https://${bucket}.${cosEndpoint}/${objectKey}`;
    
    // 计算当前时间戳和过期时间（30分钟后）
    const now = Math.floor(Date.now() / 1000);
    const expiration = now + 1800; // 30分钟有效期
    
    // 构建Policy声明，包含上传条件
    const policy = {
      "expiration": new Date(expiration * 1000).toISOString(),
      "conditions": [
        {"bucket": bucket},
        {"key": objectKey},
        ["content-length-range", 0, 10485760], // 限制文件大小最大10MB
        {"success_action_status": "200"}
      ]
    };
    
    // 如果有临时token，添加到policy中
    if (sessionToken) {
      policy.conditions.push({"x-cos-security-token": sessionToken});
    }
    
    // 将policy编码为base64字符串
    const policyStr = JSON.stringify(policy);
    const policyBase64 = wx.arrayBufferToBase64(new Uint8Array([...policyStr].map(char => char.charCodeAt(0))));
    
    // 计算签名（实际应使用HMAC-SHA1）
    const signature = this.calculateSignature(policyBase64, tmpSecretKey);
    
    // 显示上传进度
    wx.showLoading({
      title: '准备上传...',
      mask: true
    });
    
    // 构建表单数据
    const formData = {
      'key': objectKey,
      'policy': policyBase64,
      'q-sign-algorithm': 'sha1',
      'q-ak': tmpSecretId,
      'q-key-time': `${now};${expiration}`,
      'q-signature': signature,
      'success_action_status': '200'
    };
    
    // 如果有临时token，添加到表单中
    if (sessionToken) {
      formData['x-cos-security-token'] = sessionToken;
    }
    
    // 使用wx.uploadFile上传
    const uploadTask = wx.uploadFile({
      url: `https://${bucket}.${cosEndpoint}`,
      filePath: filePath,
      name: 'file',
      formData: formData,
      success: (res) => {
        console.log('上传结果:', res);
        wx.hideLoading();
        if (res.statusCode >= 200 && res.statusCode < 300) {
          callback({
            success: true,
            url: cosUrl,
            objectKey: objectKey
          });
        } else {
          callback({
            success: false,
            message: '上传失败，状态码: ' + res.statusCode
          });
        }
      },
      fail: (err) => {
        console.error('上传失败:', err);
        wx.hideLoading();
        callback({
          success: false,
          message: '上传请求失败: ' + (err.errMsg || JSON.stringify(err))
        });
      }
    });
    
    // 监听上传进度
    uploadTask.onProgressUpdate((res) => {
      const progress = res.progress;
      if (progress < 100) {
        wx.showLoading({
          title: `上传中 ${progress}%`,
          mask: true
        });
      }
    });
  },
  
  // 计算签名（简化版，实际应使用HMAC-SHA1）
  calculateSignature(policyBase64, secretKey) {
    // 这是一个简化的示例签名方法
    // 实际应用中应该使用微信小程序支持的方式计算HMAC-SHA1
    const strToSign = policyBase64;
    
    // 为了示例，我们使用一个简单的哈希函数
    // 在实际应用中，请使用真正的HMAC-SHA1算法
    let signature = '';
    for (let i = 0; i < strToSign.length; i++) {
      const charCode = strToSign.charCodeAt(i) ^ secretKey.charCodeAt(i % secretKey.length);
      signature += charCode.toString(16).padStart(2, '0');
    }
    
    return signature;
  },
  
  // 获取临时密钥（实际应用中应该从您的服务器获取）
  getTempCosKey(callback) {
    // 判断环境：生产环境从服务器获取，开发环境使用本地配置
    const env = __wxConfig.envVersion; // develop(开发版), trial(体验版), release(正式版)
    
    if (env === 'release') {
      // 生产环境: 从服务器获取临时密钥（安全）
      wx.request({
        url: 'https://您的服务器域名/api/get-cos-temp-key', // 您的临时密钥服务地址
        method: 'GET',
        success: (res) => {
          if (res.data && res.data.credentials) {
            callback({
              success: true,
              credentials: res.data.credentials
            });
          } else {
            callback({
              success: false,
              message: '获取临时密钥失败'
            });
          }
        },
        fail: () => {
          callback({
            success: false,
            message: '获取临时密钥请求失败'
          });
        }
      });
    } else {
      // 开发环境: 使用直接配置的密钥（不安全，仅用于开发测试）
      // 注意：此方法不安全，仅适用于开发测试环境
      const { secretId, secretKey } = this.globalData.tcbConfig;
      if (!secretId || !secretKey) {
        callback({
          success: false, 
          message: '未配置开发环境密钥'
        });
        return;
      }
      
      // 模拟临时密钥
      callback({
        success: true,
        credentials: {
          tmpSecretId: secretId,
          tmpSecretKey: secretKey,
          sessionToken: '', // 开发环境下可不使用临时token
          expiration: new Date(new Date().getTime() + 1800000).toISOString()
        }
      });
    }
  },
  
  // 获取文件的MD5值，用于唯一文件名
  getFileMD5(filePath, callback) {
    wx.getFileSystemManager().readFile({
      filePath: filePath,
      success: (res) => {
        // 简化的MD5计算，实际应用中可以使用更完整的MD5库
        const timestamp = new Date().getTime();
        const random = Math.floor(Math.random() * 10000);
        const filename = `${timestamp}_${random}`;
        callback(filename);
      },
      fail: () => {
        // 获取文件失败时，使用时间戳作为文件名
        const timestamp = new Date().getTime();
        callback(`${timestamp}`);
      }
    });
  },
  
  // 初始化分享记录
  initShareRecords() {
    const shareRecords = wx.getStorageSync('shareRecords') || {};
    this.globalData.shareRecords = shareRecords;
    wx.setStorageSync('shareRecords', shareRecords);
  },
  
  // 处理分享奖励
  handleShareReward(shareTicket, fromOpenid) {
    // 如果没有记录分享者的openid，则无法判断是否重复，默认给予奖励
    if (!fromOpenid) {
      console.log('无法识别分享者openid，默认给予奖励');
      this.increaseUsageCount(1);
      return true;
    }
    
    // 检查是否已经给这个好友的分享奖励过
    if (this.hasSharedByFriend(fromOpenid)) {
      console.log('该好友已经给予过分享奖励，不重复奖励');
      return false;
    }
    
    // 记录这个好友已经分享过
    this.recordShareFriend(fromOpenid);
    
    // 增加使用次数
    this.increaseUsageCount(1);
    return true;
  },
  
  // 检查是否已经被该好友分享过
  hasSharedByFriend(openid) {
    return !!this.globalData.shareRecords[openid];
  },
  
  // 记录分享好友
  recordShareFriend(openid) {
    // 记录分享时间
    this.globalData.shareRecords[openid] = new Date().toISOString();
    
    // 保存到存储
    wx.setStorageSync('shareRecords', this.globalData.shareRecords);
  },
  
  // 增加使用次数
  increaseUsageCount(count) {
    const currentCount = this.globalData.freeUsageCount;
    const newCount = currentCount + count;
    
    // 使用统一的更新方法
    this.updateFreeUsageCount(newCount);
    
    return newCount;
  },
  
  // 恢复隐私授权状态
  restorePrivacyState() {
    try {
      const privacyAuthorized = wx.getStorageSync('privacyAuthorized');
      this.globalData.privacyAuthorized = !!privacyAuthorized;
      console.log('恢复隐私授权状态:', this.globalData.privacyAuthorized);
    } catch (e) {
      console.error('读取隐私授权状态失败:', e);
    }
  }
})
